
// MIT License
// 
// Copyright (c) 2009-2017 Luca Piccioni
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// 
// This file is automatically generated

#pragma warning disable 649, 1572, 1573

// ReSharper disable RedundantUsingDirective
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

using Khronos;

// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
// ReSharper disable JoinDeclarationAndInitializer

namespace OpenGL
{
	public partial class Gl
	{
		/// <summary>
		/// [GL] Value of GL_VERTEX_STATE_PROGRAM_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_STATE_PROGRAM_NV = 0x8621;

		/// <summary>
		/// [GL] Value of GL_ATTRIB_ARRAY_SIZE_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int ATTRIB_ARRAY_SIZE_NV = 0x8623;

		/// <summary>
		/// [GL] Value of GL_ATTRIB_ARRAY_STRIDE_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int ATTRIB_ARRAY_STRIDE_NV = 0x8624;

		/// <summary>
		/// [GL] Value of GL_ATTRIB_ARRAY_TYPE_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int ATTRIB_ARRAY_TYPE_NV = 0x8625;

		/// <summary>
		/// [GL] Value of GL_CURRENT_ATTRIB_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int CURRENT_ATTRIB_NV = 0x8626;

		/// <summary>
		/// [GL] Value of GL_MODELVIEW_PROJECTION_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MODELVIEW_PROJECTION_NV = 0x8629;

		/// <summary>
		/// [GL] Value of GL_IDENTITY_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int IDENTITY_NV = 0x862A;

		/// <summary>
		/// [GL] Value of GL_INVERSE_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int INVERSE_NV = 0x862B;

		/// <summary>
		/// [GL] Value of GL_TRANSPOSE_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int TRANSPOSE_NV = 0x862C;

		/// <summary>
		/// [GL] Value of GL_INVERSE_TRANSPOSE_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int INVERSE_TRANSPOSE_NV = 0x862D;

		/// <summary>
		/// [GL] Value of GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E;

		/// <summary>
		/// [GL] Value of GL_MAX_TRACK_MATRICES_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAX_TRACK_MATRICES_NV = 0x862F;

		/// <summary>
		/// [GL] Value of GL_MATRIX0_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX0_NV = 0x8630;

		/// <summary>
		/// [GL] Value of GL_MATRIX1_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX1_NV = 0x8631;

		/// <summary>
		/// [GL] Value of GL_MATRIX2_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX2_NV = 0x8632;

		/// <summary>
		/// [GL] Value of GL_MATRIX3_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX3_NV = 0x8633;

		/// <summary>
		/// [GL] Value of GL_MATRIX4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX4_NV = 0x8634;

		/// <summary>
		/// [GL] Value of GL_MATRIX5_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX5_NV = 0x8635;

		/// <summary>
		/// [GL] Value of GL_MATRIX6_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX6_NV = 0x8636;

		/// <summary>
		/// [GL] Value of GL_MATRIX7_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MATRIX7_NV = 0x8637;

		/// <summary>
		/// [GL] Value of GL_PROGRAM_PARAMETER_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int PROGRAM_PARAMETER_NV = 0x8644;

		/// <summary>
		/// [GL] Value of GL_ATTRIB_ARRAY_POINTER_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int ATTRIB_ARRAY_POINTER_NV = 0x8645;

		/// <summary>
		/// [GL] Value of GL_PROGRAM_TARGET_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int PROGRAM_TARGET_NV = 0x8646;

		/// <summary>
		/// [GL] Value of GL_PROGRAM_RESIDENT_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int PROGRAM_RESIDENT_NV = 0x8647;

		/// <summary>
		/// [GL] Value of GL_TRACK_MATRIX_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int TRACK_MATRIX_NV = 0x8648;

		/// <summary>
		/// [GL] Value of GL_TRACK_MATRIX_TRANSFORM_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int TRACK_MATRIX_TRANSFORM_NV = 0x8649;

		/// <summary>
		/// [GL] Value of GL_VERTEX_PROGRAM_BINDING_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_PROGRAM_BINDING_NV = 0x864A;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY0_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY0_NV = 0x8650;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY1_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY1_NV = 0x8651;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY2_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY2_NV = 0x8652;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY3_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY3_NV = 0x8653;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY4_NV = 0x8654;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY5_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY5_NV = 0x8655;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY6_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY6_NV = 0x8656;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY7_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY7_NV = 0x8657;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY8_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY8_NV = 0x8658;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY9_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY9_NV = 0x8659;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY10_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY10_NV = 0x865A;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY11_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY11_NV = 0x865B;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY12_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY12_NV = 0x865C;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY13_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY13_NV = 0x865D;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY14_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY14_NV = 0x865E;

		/// <summary>
		/// [GL] Value of GL_VERTEX_ATTRIB_ARRAY15_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int VERTEX_ATTRIB_ARRAY15_NV = 0x865F;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB0_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB0_4_NV = 0x8660;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB1_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB1_4_NV = 0x8661;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB2_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB2_4_NV = 0x8662;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB3_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB3_4_NV = 0x8663;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB4_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB4_4_NV = 0x8664;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB5_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB5_4_NV = 0x8665;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB6_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB6_4_NV = 0x8666;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB7_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB7_4_NV = 0x8667;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB8_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB8_4_NV = 0x8668;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB9_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB9_4_NV = 0x8669;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB10_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB10_4_NV = 0x866A;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB11_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB11_4_NV = 0x866B;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB12_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB12_4_NV = 0x866C;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB13_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB13_4_NV = 0x866D;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB14_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB14_4_NV = 0x866E;

		/// <summary>
		/// [GL] Value of GL_MAP1_VERTEX_ATTRIB15_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP1_VERTEX_ATTRIB15_4_NV = 0x866F;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB0_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB0_4_NV = 0x8670;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB1_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB1_4_NV = 0x8671;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB2_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB2_4_NV = 0x8672;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB3_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB3_4_NV = 0x8673;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB4_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB4_4_NV = 0x8674;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB5_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB5_4_NV = 0x8675;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB6_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB6_4_NV = 0x8676;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB7_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB7_4_NV = 0x8677;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB8_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB8_4_NV = 0x8678;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB9_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB9_4_NV = 0x8679;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB10_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB10_4_NV = 0x867A;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB11_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB11_4_NV = 0x867B;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB12_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB12_4_NV = 0x867C;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB13_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB13_4_NV = 0x867D;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB14_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB14_4_NV = 0x867E;

		/// <summary>
		/// [GL] Value of GL_MAP2_VERTEX_ATTRIB15_4_NV symbol.
		/// </summary>
		[RequiredByFeature("GL_NV_vertex_program")]
		public const int MAP2_VERTEX_ATTRIB15_4_NV = 0x867F;

		/// <summary>
		/// [GL] glAreProgramsResidentNV: Binding for glAreProgramsResidentNV.
		/// </summary>
		/// <param name="programs">
		/// A <see cref="T:uint[]"/>.
		/// </param>
		/// <param name="residences">
		/// A <see cref="T:byte[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static bool AreProgramsResidentNV(uint[] programs, [Out] byte[] residences)
		{
			bool retValue;

			unsafe {
				fixed (uint* p_programs = programs)
				fixed (byte* p_residences = residences)
				{
					Debug.Assert(Delegates.pglAreProgramsResidentNV != null, "pglAreProgramsResidentNV not implemented");
					retValue = Delegates.pglAreProgramsResidentNV(programs.Length, p_programs, p_residences);
					LogCommand("glAreProgramsResidentNV", retValue, programs.Length, programs, residences					);
				}
			}
			DebugCheckErrors(retValue);

			return (retValue);
		}

		/// <summary>
		/// [GL] glExecuteProgramNV: Binding for glExecuteProgramNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="id">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ExecuteProgramNV(int target, uint id, float[] @params)
		{
			Debug.Assert(@params.Length >= 4);
			unsafe {
				fixed (float* p_params = @params)
				{
					Debug.Assert(Delegates.pglExecuteProgramNV != null, "pglExecuteProgramNV not implemented");
					Delegates.pglExecuteProgramNV(target, id, p_params);
					LogCommand("glExecuteProgramNV", null, target, id, @params					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glGetProgramParameterdvNV: Binding for glGetProgramParameterdvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void GetProgramParameterNV(int target, uint index, int pname, [Out] double[] @params)
		{
			Debug.Assert(@params.Length >= 4);
			unsafe {
				fixed (double* p_params = @params)
				{
					Debug.Assert(Delegates.pglGetProgramParameterdvNV != null, "pglGetProgramParameterdvNV not implemented");
					Delegates.pglGetProgramParameterdvNV(target, index, pname, p_params);
					LogCommand("glGetProgramParameterdvNV", null, target, index, pname, @params					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glGetProgramParameterfvNV: Binding for glGetProgramParameterfvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void GetProgramParameterNV(int target, uint index, int pname, [Out] float[] @params)
		{
			Debug.Assert(@params.Length >= 4);
			unsafe {
				fixed (float* p_params = @params)
				{
					Debug.Assert(Delegates.pglGetProgramParameterfvNV != null, "pglGetProgramParameterfvNV not implemented");
					Delegates.pglGetProgramParameterfvNV(target, index, pname, p_params);
					LogCommand("glGetProgramParameterfvNV", null, target, index, pname, @params					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glGetProgramivNV: Binding for glGetProgramivNV.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:int[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void GetProgramNV(uint id, int pname, [Out] int[] @params)
		{
			Debug.Assert(@params.Length >= 4);
			unsafe {
				fixed (int* p_params = @params)
				{
					Debug.Assert(Delegates.pglGetProgramivNV != null, "pglGetProgramivNV not implemented");
					Delegates.pglGetProgramivNV(id, pname, p_params);
					LogCommand("glGetProgramivNV", null, id, pname, @params					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glGetProgramStringNV: Binding for glGetProgramStringNV.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="program">
		/// A <see cref="T:byte[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void GetProgramStringNV(uint id, int pname, [Out] byte[] program)
		{
			unsafe {
				fixed (byte* p_program = program)
				{
					Debug.Assert(Delegates.pglGetProgramStringNV != null, "pglGetProgramStringNV not implemented");
					Delegates.pglGetProgramStringNV(id, pname, p_program);
					LogCommand("glGetProgramStringNV", null, id, pname, program					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glGetTrackMatrixivNV: Binding for glGetTrackMatrixivNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="address">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void GetTrackMatrixNV(int target, uint address, int pname, out int @params)
		{
			unsafe {
				fixed (int* p_params = &@params)
				{
					Debug.Assert(Delegates.pglGetTrackMatrixivNV != null, "pglGetTrackMatrixivNV not implemented");
					Delegates.pglGetTrackMatrixivNV(target, address, pname, p_params);
					LogCommand("glGetTrackMatrixivNV", null, target, address, pname, @params					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glLoadProgramNV: Binding for glLoadProgramNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="id">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="program">
		/// A <see cref="T:byte[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void LoadProgramNV(int target, uint id, byte[] program)
		{
			unsafe {
				fixed (byte* p_program = program)
				{
					Debug.Assert(Delegates.pglLoadProgramNV != null, "pglLoadProgramNV not implemented");
					Delegates.pglLoadProgramNV(target, id, program.Length, p_program);
					LogCommand("glLoadProgramNV", null, target, id, program.Length, program					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glProgramParameter4dNV: Binding for glProgramParameter4dNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:double"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ProgramParameter4NV(int target, uint index, double x, double y, double z, double w)
		{
			Debug.Assert(Delegates.pglProgramParameter4dNV != null, "pglProgramParameter4dNV not implemented");
			Delegates.pglProgramParameter4dNV(target, index, x, y, z, w);
			LogCommand("glProgramParameter4dNV", null, target, index, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glProgramParameter4dvNV: Binding for glProgramParameter4dvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ProgramParameter4NV(int target, uint index, double[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (double* p_v = v)
				{
					Debug.Assert(Delegates.pglProgramParameter4dvNV != null, "pglProgramParameter4dvNV not implemented");
					Delegates.pglProgramParameter4dvNV(target, index, p_v);
					LogCommand("glProgramParameter4dvNV", null, target, index, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glProgramParameter4fNV: Binding for glProgramParameter4fNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ProgramParameter4NV(int target, uint index, float x, float y, float z, float w)
		{
			Debug.Assert(Delegates.pglProgramParameter4fNV != null, "pglProgramParameter4fNV not implemented");
			Delegates.pglProgramParameter4fNV(target, index, x, y, z, w);
			LogCommand("glProgramParameter4fNV", null, target, index, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glProgramParameter4fvNV: Binding for glProgramParameter4fvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ProgramParameter4NV(int target, uint index, float[] v)
		{
			Debug.Assert(v.Length >= 4);
			unsafe {
				fixed (float* p_v = v)
				{
					Debug.Assert(Delegates.pglProgramParameter4fvNV != null, "pglProgramParameter4fvNV not implemented");
					Delegates.pglProgramParameter4fvNV(target, index, p_v);
					LogCommand("glProgramParameter4fvNV", null, target, index, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glProgramParameters4dvNV: Binding for glProgramParameters4dvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ProgramParameters4NV(int target, uint index, double[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 4) == 0, "empty or not multiple of 4");
			unsafe {
				fixed (double* p_v = v)
				{
					Debug.Assert(Delegates.pglProgramParameters4dvNV != null, "pglProgramParameters4dvNV not implemented");
					Delegates.pglProgramParameters4dvNV(target, index, v.Length / 4, p_v);
					LogCommand("glProgramParameters4dvNV", null, target, index, v.Length / 4, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glProgramParameters4fvNV: Binding for glProgramParameters4fvNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void ProgramParameters4NV(int target, uint index, float[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 4) == 0, "empty or not multiple of 4");
			unsafe {
				fixed (float* p_v = v)
				{
					Debug.Assert(Delegates.pglProgramParameters4fvNV != null, "pglProgramParameters4fvNV not implemented");
					Delegates.pglProgramParameters4fvNV(target, index, v.Length / 4, p_v);
					LogCommand("glProgramParameters4fvNV", null, target, index, v.Length / 4, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glRequestResidentProgramsNV: Binding for glRequestResidentProgramsNV.
		/// </summary>
		/// <param name="programs">
		/// A <see cref="T:uint[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void RequestResidentProgramsNV(uint[] programs)
		{
			unsafe {
				fixed (uint* p_programs = programs)
				{
					Debug.Assert(Delegates.pglRequestResidentProgramsNV != null, "pglRequestResidentProgramsNV not implemented");
					Delegates.pglRequestResidentProgramsNV(programs.Length, p_programs);
					LogCommand("glRequestResidentProgramsNV", null, programs.Length, programs					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glTrackMatrixNV: Binding for glTrackMatrixNV.
		/// </summary>
		/// <param name="target">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="address">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="matrix">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="transform">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void TrackMatrixNV(int target, uint address, int matrix, int transform)
		{
			Debug.Assert(Delegates.pglTrackMatrixNV != null, "pglTrackMatrixNV not implemented");
			Delegates.pglTrackMatrixNV(target, address, matrix, transform);
			LogCommand("glTrackMatrixNV", null, target, address, matrix, transform			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribPointerNV: Binding for glVertexAttribPointerNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="fsize">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="type">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:IntPtr"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribPointerNV(uint index, int fsize, int type, int stride, IntPtr pointer)
		{
			Debug.Assert(Delegates.pglVertexAttribPointerNV != null, "pglVertexAttribPointerNV not implemented");
			Delegates.pglVertexAttribPointerNV(index, fsize, type, stride, pointer);
			LogCommand("glVertexAttribPointerNV", null, index, fsize, type, stride, pointer			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribPointerNV: Binding for glVertexAttribPointerNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="fsize">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="type">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:object"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribPointerNV(uint index, int fsize, int type, int stride, object pointer)
		{
			GCHandle pin_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned);
			try {
				VertexAttribPointerNV(index, fsize, type, stride, pin_pointer.AddrOfPinnedObject());
			} finally {
				pin_pointer.Free();
			}
		}

		/// <summary>
		/// [GL] glVertexAttribs1dvNV: Binding for glVertexAttribs1dvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs1NV(uint index, double[] v)
		{
			unsafe {
				fixed (double* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs1dvNV != null, "pglVertexAttribs1dvNV not implemented");
					Delegates.pglVertexAttribs1dvNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs1dvNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs1fvNV: Binding for glVertexAttribs1fvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs1NV(uint index, float[] v)
		{
			unsafe {
				fixed (float* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs1fvNV != null, "pglVertexAttribs1fvNV not implemented");
					Delegates.pglVertexAttribs1fvNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs1fvNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs1svNV: Binding for glVertexAttribs1svNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs1NV(uint index, short[] v)
		{
			unsafe {
				fixed (short* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs1svNV != null, "pglVertexAttribs1svNV not implemented");
					Delegates.pglVertexAttribs1svNV(index, v.Length, p_v);
					LogCommand("glVertexAttribs1svNV", null, index, v.Length, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs2dvNV: Binding for glVertexAttribs2dvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs2NV(uint index, double[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 2) == 0, "empty or not multiple of 2");
			unsafe {
				fixed (double* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs2dvNV != null, "pglVertexAttribs2dvNV not implemented");
					Delegates.pglVertexAttribs2dvNV(index, v.Length / 2, p_v);
					LogCommand("glVertexAttribs2dvNV", null, index, v.Length / 2, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs2fvNV: Binding for glVertexAttribs2fvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs2NV(uint index, float[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 2) == 0, "empty or not multiple of 2");
			unsafe {
				fixed (float* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs2fvNV != null, "pglVertexAttribs2fvNV not implemented");
					Delegates.pglVertexAttribs2fvNV(index, v.Length / 2, p_v);
					LogCommand("glVertexAttribs2fvNV", null, index, v.Length / 2, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs2svNV: Binding for glVertexAttribs2svNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs2NV(uint index, short[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 2) == 0, "empty or not multiple of 2");
			unsafe {
				fixed (short* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs2svNV != null, "pglVertexAttribs2svNV not implemented");
					Delegates.pglVertexAttribs2svNV(index, v.Length / 2, p_v);
					LogCommand("glVertexAttribs2svNV", null, index, v.Length / 2, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs3dvNV: Binding for glVertexAttribs3dvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs3NV(uint index, double[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 3) == 0, "empty or not multiple of 3");
			unsafe {
				fixed (double* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs3dvNV != null, "pglVertexAttribs3dvNV not implemented");
					Delegates.pglVertexAttribs3dvNV(index, v.Length / 3, p_v);
					LogCommand("glVertexAttribs3dvNV", null, index, v.Length / 3, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs3fvNV: Binding for glVertexAttribs3fvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs3NV(uint index, float[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 3) == 0, "empty or not multiple of 3");
			unsafe {
				fixed (float* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs3fvNV != null, "pglVertexAttribs3fvNV not implemented");
					Delegates.pglVertexAttribs3fvNV(index, v.Length / 3, p_v);
					LogCommand("glVertexAttribs3fvNV", null, index, v.Length / 3, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs3svNV: Binding for glVertexAttribs3svNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs3NV(uint index, short[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 3) == 0, "empty or not multiple of 3");
			unsafe {
				fixed (short* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs3svNV != null, "pglVertexAttribs3svNV not implemented");
					Delegates.pglVertexAttribs3svNV(index, v.Length / 3, p_v);
					LogCommand("glVertexAttribs3svNV", null, index, v.Length / 3, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs4dvNV: Binding for glVertexAttribs4dvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs4NV(uint index, double[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 4) == 0, "empty or not multiple of 4");
			unsafe {
				fixed (double* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs4dvNV != null, "pglVertexAttribs4dvNV not implemented");
					Delegates.pglVertexAttribs4dvNV(index, v.Length / 4, p_v);
					LogCommand("glVertexAttribs4dvNV", null, index, v.Length / 4, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs4fvNV: Binding for glVertexAttribs4fvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs4NV(uint index, float[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 4) == 0, "empty or not multiple of 4");
			unsafe {
				fixed (float* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs4fvNV != null, "pglVertexAttribs4fvNV not implemented");
					Delegates.pglVertexAttribs4fvNV(index, v.Length / 4, p_v);
					LogCommand("glVertexAttribs4fvNV", null, index, v.Length / 4, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs4svNV: Binding for glVertexAttribs4svNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs4NV(uint index, short[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 4) == 0, "empty or not multiple of 4");
			unsafe {
				fixed (short* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs4svNV != null, "pglVertexAttribs4svNV not implemented");
					Delegates.pglVertexAttribs4svNV(index, v.Length / 4, p_v);
					LogCommand("glVertexAttribs4svNV", null, index, v.Length / 4, v					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexAttribs4ubvNV: Binding for glVertexAttribs4ubvNV.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:uint"/>.
		/// </param>
		/// <param name="v">
		/// A <see cref="T:byte[]"/>.
		/// </param>
		[RequiredByFeature("GL_NV_vertex_program")]
		public static void VertexAttribs4NV(uint index, byte[] v)
		{
			Debug.Assert(v.Length > 0 && (v.Length % 4) == 0, "empty or not multiple of 4");
			unsafe {
				fixed (byte* p_v = v)
				{
					Debug.Assert(Delegates.pglVertexAttribs4ubvNV != null, "pglVertexAttribs4ubvNV not implemented");
					Delegates.pglVertexAttribs4ubvNV(index, v.Length / 4, p_v);
					LogCommand("glVertexAttribs4ubvNV", null, index, v.Length / 4, v					);
				}
			}
			DebugCheckErrors(null);
		}

		internal static unsafe partial class Delegates
		{
			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			[return: MarshalAs(UnmanagedType.I1)]
			internal delegate bool glAreProgramsResidentNV(int n, uint* programs, byte* residences);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glAreProgramsResidentNV pglAreProgramsResidentNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glExecuteProgramNV(int target, uint id, float* @params);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glExecuteProgramNV pglExecuteProgramNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glGetProgramParameterdvNV(int target, uint index, int pname, double* @params);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glGetProgramParameterdvNV pglGetProgramParameterdvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glGetProgramParameterfvNV(int target, uint index, int pname, float* @params);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glGetProgramParameterfvNV pglGetProgramParameterfvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glGetProgramivNV(uint id, int pname, int* @params);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glGetProgramivNV pglGetProgramivNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glGetProgramStringNV(uint id, int pname, byte* program);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glGetProgramStringNV pglGetProgramStringNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glGetTrackMatrixivNV(int target, uint address, int pname, int* @params);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glGetTrackMatrixivNV pglGetTrackMatrixivNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glLoadProgramNV(int target, uint id, int len, byte* program);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glLoadProgramNV pglLoadProgramNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glProgramParameter4dNV(int target, uint index, double x, double y, double z, double w);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glProgramParameter4dNV pglProgramParameter4dNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glProgramParameter4dvNV(int target, uint index, double* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glProgramParameter4dvNV pglProgramParameter4dvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glProgramParameter4fNV(int target, uint index, float x, float y, float z, float w);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glProgramParameter4fNV pglProgramParameter4fNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glProgramParameter4fvNV(int target, uint index, float* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glProgramParameter4fvNV pglProgramParameter4fvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glProgramParameters4dvNV(int target, uint index, int count, double* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glProgramParameters4dvNV pglProgramParameters4dvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glProgramParameters4fvNV(int target, uint index, int count, float* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glProgramParameters4fvNV pglProgramParameters4fvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glRequestResidentProgramsNV(int n, uint* programs);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glRequestResidentProgramsNV pglRequestResidentProgramsNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glTrackMatrixNV(int target, uint address, int matrix, int transform);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glTrackMatrixNV pglTrackMatrixNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribPointerNV(uint index, int fsize, int type, int stride, IntPtr pointer);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribPointerNV pglVertexAttribPointerNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs1dvNV(uint index, int count, double* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs1dvNV pglVertexAttribs1dvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs1fvNV(uint index, int count, float* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs1fvNV pglVertexAttribs1fvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs1svNV(uint index, int count, short* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs1svNV pglVertexAttribs1svNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs2dvNV(uint index, int count, double* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs2dvNV pglVertexAttribs2dvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs2fvNV(uint index, int count, float* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs2fvNV pglVertexAttribs2fvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs2svNV(uint index, int count, short* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs2svNV pglVertexAttribs2svNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs3dvNV(uint index, int count, double* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs3dvNV pglVertexAttribs3dvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs3fvNV(uint index, int count, float* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs3fvNV pglVertexAttribs3fvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs3svNV(uint index, int count, short* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs3svNV pglVertexAttribs3svNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs4dvNV(uint index, int count, double* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs4dvNV pglVertexAttribs4dvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs4fvNV(uint index, int count, float* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs4fvNV pglVertexAttribs4fvNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs4svNV(uint index, int count, short* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs4svNV pglVertexAttribs4svNV;

			[RequiredByFeature("GL_NV_vertex_program")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexAttribs4ubvNV(uint index, int count, byte* v);

			[RequiredByFeature("GL_NV_vertex_program")]
			[ThreadStatic]
			internal static glVertexAttribs4ubvNV pglVertexAttribs4ubvNV;

		}
	}

}
